/**
 * 用户管理控制器
 * 处理后台对普通用户的管理功能
 */

const User = require('../../models/User');
const logger = require('../../logger');

class UserController {
    /**
     * 获取用户列表
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async getUserList(req, res) {
        try {
            const { page = 1, limit = 20, search = '' } = req.query;
            
            // 构建查询条件
            const query = {};
            if (search) {
                query.$or = [
                    { username: { $regex: search, $options: 'i' } },
                    { email: { $regex: search, $options: 'i' } },
                    { phone: { $regex: search, $options: 'i' } }
                ];
            }
            
            // 计算偏移量
            const skip = (page - 1) * limit;
            
            // 查询用户数据
            const users = await User.find(query)
                .skip(skip)
                .limit(parseInt(limit))
                .sort({ createdAt: -1 })
                .select('-password');
            
            // 获取总数
            const total = await User.countDocuments(query);
            
            logger.info(`获取用户列表成功: 第${page}页, 每页${limit}条`);
            
            res.status(200).json({
                users,
                pagination: {
                    total,
                    page: parseInt(page),
                    limit: parseInt(limit),
                    pages: Math.ceil(total / limit)
                }
            });
        } catch (error) {
            logger.error(`获取用户列表失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '获取用户列表失败'
            });
        }
    }
    
    /**
     * 获取用户详情
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async getUserDetail(req, res) {
        try {
            const { id } = req.params;
            
            const user = await User.findById(id).select('-password');
            
            if (!user) {
                return res.status(404).json({
                    error: 'NotFound',
                    message: '用户不存在'
                });
            }
            
            logger.info(`获取用户详情成功: 用户ID=${id}`);
            res.status(200).json(user);
        } catch (error) {
            logger.error(`获取用户详情失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '获取用户详情失败'
            });
        }
    }
    
    /**
     * 更新用户信息
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async updateUser(req, res) {
        try {
            const { id } = req.params;
            const updateData = req.body;
            
            // 移除敏感字段，不允许更新
            delete updateData.password;
            delete updateData.role;
            delete updateData.createdAt;
            
            const user = await User.findByIdAndUpdate(id, updateData, { new: true }).select('-password');
            
            if (!user) {
                return res.status(404).json({
                    error: 'NotFound',
                    message: '用户不存在'
                });
            }
            
            logger.info(`更新用户信息成功: 用户ID=${id}`);
            res.status(200).json(user);
        } catch (error) {
            logger.error(`更新用户信息失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '更新用户信息失败'
            });
        }
    }
    
    /**
     * 更新用户状态
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async updateUserStatus(req, res) {
        try {
            const { id } = req.params;
            const { status } = req.body;
            
            // 验证状态值
            const validStatuses = ['active', 'inactive', 'suspended'];
            if (!validStatuses.includes(status)) {
                return res.status(400).json({
                    error: 'ValidationError',
                    message: '无效的状态值'
                });
            }
            
            const user = await User.findByIdAndUpdate(
                id, 
                { status }, 
                { new: true }
            ).select('-password');
            
            if (!user) {
                return res.status(404).json({
                    error: 'NotFound',
                    message: '用户不存在'
                });
            }
            
            logger.info(`更新用户状态成功: 用户ID=${id}, 状态=${status}`);
            res.status(200).json(user);
        } catch (error) {
            logger.error(`更新用户状态失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '更新用户状态失败'
            });
        }
    }
    
    /**
     * 获取用户活动日志
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async getUserActivities(req, res) {
        try {
            const { id } = req.params;
            const { page = 1, limit = 50 } = req.query;
            
            // 这里假设User模型中有activities字段或相关关联
            // 实际实现可能需要连接到活动日志表
            const user = await User.findById(id);
            
            if (!user) {
                return res.status(404).json({
                    error: 'NotFound',
                    message: '用户不存在'
                });
            }
            
            // 模拟活动数据
            const activities = [];
            const total = 0;
            
            logger.info(`获取用户活动日志成功: 用户ID=${id}`);
            res.status(200).json({
                activities,
                pagination: {
                    total,
                    page: parseInt(page),
                    limit: parseInt(limit),
                    pages: Math.ceil(total / limit)
                }
            });
        } catch (error) {
            logger.error(`获取用户活动日志失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '获取用户活动日志失败'
            });
        }
    }
    
    /**
     * 获取用户统计信息
     * @param {Object} req - Express请求对象
     * @param {Object} res - Express响应对象
     */
    async getUserStats(req, res) {
        try {
            // 获取各种统计数据
            const totalUsers = await User.countDocuments();
            const activeUsers = await User.countDocuments({ status: 'active' });
            const newUsersToday = await User.countDocuments({
                createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
            });
            const newUsersThisWeek = await User.countDocuments({
                createdAt: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
            });
            
            logger.info('获取用户统计信息成功');
            res.status(200).json({
                totalUsers,
                activeUsers,
                newUsersToday,
                newUsersThisWeek,
                inactiveUsers: totalUsers - activeUsers
            });
        } catch (error) {
            logger.error(`获取用户统计信息失败: ${error.message}`);
            res.status(500).json({
                error: 'InternalServerError',
                message: '获取用户统计信息失败'
            });
        }
    }
}

module.exports = new UserController();